home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / WW3DCompoundCommand.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  7.6 KB  |  332 lines
  1.  
  2. #import "WW3DCompoundCommand.h"
  3.  
  4. @implementation WW3DCompoundCommand
  5.  
  6. + initialize { return [WW3DCompoundCommand setVersion:1], self; }
  7.  
  8. - init
  9. {
  10.   [super init];
  11.  
  12.   ribCommandList  = [[RIBCommandList alloc] init];
  13.   dirtyBoundingBox = YES;
  14.   
  15.   return self;
  16. }
  17.  
  18.  
  19. - awake
  20. {
  21.     [super awake];
  22.     dirtyBoundingBox = YES;
  23.     return self;
  24. }
  25.  
  26.  
  27. - setRIBCommandList:newRIBCommandList { ribCommandList = newRIBCommandList; return self; }
  28. - ribCommandList { return ribCommandList; }
  29.  
  30. - copyFromZone:(NXZone *)zone
  31. {
  32.    id   newCopy = [super copyFromZone:zone];
  33.    id   newList = [[self ribCommandList] copyFromZone:zone];
  34.  
  35.  
  36.    //NXLogError("WW3DCompoundCommand: my list is %p - the copy is %p", ribCommandList, newList);
  37.    [newCopy setRIBCommandList:newList];
  38.    return newCopy;
  39. }
  40.  
  41. // see, this is potentially interesting, if a simple linear
  42. // interpolation of my ribCommandList did not represent the appropriate
  43. // linear interpolation of me, I could interpose some other list of
  44. // objects.  For example, there might some discontinuity between
  45. // this instance and "b", such as an enumerated 
  46. // parameter (i.e. "sleepy, grumpy, happy, ecstatic") which doesn't
  47. // have an obvious interpolation.  
  48. // In the case of this simple composite object, however, 
  49. // it is true that simply interpolating my ribCommandList is enough.
  50. - lerpWith:b by:(float)uValue
  51. {
  52.    id  newMe = nil, newRIBCommandList;
  53.  
  54.  
  55.    if (([self class] != [b class]) || (uValue <= 0.0))
  56.    {  return self;
  57.    }
  58.  
  59.    if (uValue >= 1.0)
  60.    {  return b;
  61.    }
  62.  
  63.    newMe = [self copyFromZone:[self zone]];
  64.    newRIBCommandList = [ribCommandList lerpWith:[b ribCommandList] by:uValue];
  65.    [[newMe ribCommandList] empty];
  66.    [newMe setRIBCommandList:newRIBCommandList];
  67.  
  68.    return newMe;
  69. }
  70.  
  71. - lerpSelfWith:b by:(float)uValue
  72. {
  73.    if (([self class] != [b class]) || (uValue <= 0.0))
  74.    {  return self;
  75.    }
  76.  
  77.    if (uValue >= 1.0)
  78.    {  return b;
  79.    }
  80.  
  81.    [ribCommandList lerpSelfWith:[b ribCommandList] by:uValue];
  82.  
  83.    return self;
  84. }
  85.  
  86. - (BOOL)isLerpable { return YES; }
  87.  
  88. - (BOOL)pushesOrPopsCTM { return NO; }
  89. - (BOOL)pushesCTM { return NO; }
  90. - (BOOL)popsCTM { return NO; }
  91.  
  92. - free
  93. {
  94.     [ribCommandList free];
  95.     return [super free];
  96. }
  97.  
  98. - (BOOL)hasBoundingBox        { return YES; }
  99. - (BOOL)isMotionBlurrable    { return YES; }
  100. - (BOOL)isCompoundCommand    { return YES; }
  101.  
  102. - setBoundingBox:(RtBound *)newBoundingBox
  103. {
  104.     N3D_CopyBound(*newBoundingBox, boundingBox);
  105.     return self;
  106. }
  107.  
  108. - calculateBoundingBoxStartingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime  
  109. {  
  110.     dirtyBoundingBox = NO;
  111.     return [self setBoundingBox:[ribCommandList boundingBoxStartingAt:shutterOpenTime endingAt:shutterCloseTime]];
  112. }
  113.  
  114. - (RtBound *)boundingBoxStartingAt:(RtFloat)intervalStartTime endingAt:(RtFloat)intervalEndTime
  115. { 
  116.    if (dirtyBoundingBox) 
  117.    {  [self calculateBoundingBoxStartingAt:intervalStartTime endingAt:intervalEndTime];
  118.    }
  119.    return &boundingBox; 
  120. }
  121.  
  122. - (float)lastSampleIsAt { return 0.0; }
  123.  
  124. - (unsigned long int)maxSampleBandwidth { return [ribCommandList maxSampleBandwidth]; }
  125.  
  126. - setMyShape:shape
  127. {
  128.     myShape = shape;
  129.     return self;
  130. }
  131.  
  132. - shape
  133. {
  134.     return myShape;
  135. }
  136.  
  137. - renderMaps:(WW3DCamera *)camera
  138.     startingAt:(RtFloat)shutterOpenTime
  139.     endingAt:(RtFloat)shutterCloseTime usingStream:(NXStream *)ns
  140. {
  141.     return self;
  142. }
  143.  
  144. - renderMaps:(WW3DCamera *)camera usingStream:(NXStream *)ns
  145. {
  146.     return self;
  147. }
  148.  
  149. - renderMaps:(WW3DCamera *)camera
  150.     startingAt:(RtFloat)shutterOpenTime
  151.     endingAt:(RtFloat)shutterCloseTime
  152. {
  153.     return self;
  154. }
  155.  
  156. - renderMaps:(WW3DCamera *)camera
  157. {
  158.     return self;
  159. }
  160.  
  161. - renderSelfAsBox:(WW3DCamera *)camera
  162.     startingAt:(RtFloat)shutterOpenTime
  163.     endingAt:(RtFloat)shutterCloseTime
  164. {
  165.     return [ribCommandList renderSelfAsBox:camera
  166.                startingAt:shutterOpenTime
  167.                endingAt:shutterCloseTime];
  168. }
  169.  
  170. - renderSelf:(WW3DCamera *)camera
  171.     startingAt:(RtFloat)shutterOpenTime
  172.     endingAt:(RtFloat)shutterCloseTime
  173. {
  174.     return [ribCommandList renderSelf:camera
  175.                startingAt:shutterOpenTime
  176.                endingAt:shutterCloseTime];
  177. }
  178.  
  179. - renderSelf:(WW3DCamera *)camera
  180. {
  181.     return [ribCommandList renderSelf:camera];
  182. }
  183.  
  184. - preRenderSelf:(WW3DCamera *)camera
  185.     startingAt:(RtFloat)shutterOpenTime
  186.     endingAt:(RtFloat)shutterCloseTime
  187. {
  188.     return [ribCommandList preRenderSelf:camera
  189.                startingAt:shutterOpenTime
  190.                endingAt:shutterCloseTime];
  191. }
  192.  
  193. - preRenderSelf:(WW3DCamera *)camera
  194. {
  195.     return [ribCommandList preRenderSelf:camera];
  196. }
  197.  
  198. - transformCTM:(WW3DAttributeState *)attributeState
  199.     startingAt:(RtFloat)shutterOpenTime
  200.     endingAt:(RtFloat)shutterCloseTime 
  201. {
  202.     return [ribCommandList transformCTM:attributeState
  203.                            startingAt:shutterOpenTime
  204.                endingAt:shutterCloseTime]; 
  205. }
  206.  
  207. // methods to make me look like a compound command:
  208. - (int)count {  return [ribCommandList count]; }
  209. - objectAt:(int)i {  return [ribCommandList objectAt:i]; }
  210.  
  211.  
  212. // WavesWorld archiving:
  213. // writeEve:(NXStream *)stream
  214. // writeScene:(NXStream *)stream
  215.  
  216. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  217. {
  218.     int  i;
  219.     
  220.     for (i = 0; i < tab; i++) {
  221.     NXPrintf(stream, "\t");
  222.     }
  223.     NXPrintf(stream, "#WW3DCompoundCommand");
  224.     return self;
  225. }
  226.  
  227. - writeScene:(NXStream *)stream atTabLevel:(int)tab
  228. {
  229.     int  i;
  230.     
  231.     for (i = 0; i < tab; i++) {
  232.     NXPrintf(stream, "\t");
  233.     }
  234.     NXPrintf(stream, "#WW3DCompoundCommand");
  235.     return self;
  236. }
  237.  
  238. - write3DTextScene:(NXStream *)stream atTabLevel:(int)tab index:(int)index time:(float)time until:(float)lastTime
  239. {
  240.    int  i;
  241.  
  242.  
  243.    for (i = 0; i < tab; i++)
  244.    {  NXPrintf(stream, "\t");
  245.    }
  246.  
  247.    NXPrintf(stream, "startShape %s; ", [[self class] name]);
  248.    // need tab
  249.    // need index (position in current list)
  250.    NXPrintf(stream, 
  251.         "EveCmd {Translate [expr { %d * $__text__(tabLength)}] [expr {$__text__(spacingFactor) * %d * $__text__(spacing) * $__text__(fontSize)}] 0 };\n", 
  252.             tab, index); 
  253.    NXPrintf(stream, "  EveCmd {WW3DText $__text__(fontName) $__text__(fontSize) {");
  254.    [self writeEve:stream atTabLevel:tab];
  255.    NXPrintf(stream, "} left;}\n");
  256.   NXPrintf(stream, "endShape;\n");
  257.  
  258.   return self;
  259. }
  260.  
  261. - writeInventorAtTime:(float)currentTime to:(NXStream *)stream atTabLevel:(int)tab
  262. {
  263.    int  i;
  264.  
  265.  
  266.    for (i = 0; i < tab; i++)
  267.    {  NXPrintf(stream, "\t");
  268.    }
  269.    NXPrintf(stream, "# ");
  270.    [self writeEve:stream atTabLevel:tab];
  271.    NXPrintf(stream, "\n");
  272.  
  273.    return [ribCommandList writeInventorAtTime:currentTime to:stream atTabLevel:tab];
  274. }
  275.  
  276. #define typeVector "@"
  277. #define typeValues &ribCommandList
  278.  
  279. - read:(NXTypedStream *)stream 
  280. {
  281.     int version;
  282.     
  283.     [super read:stream];
  284.     version = NXTypedStreamClassVersion(stream,"WW3DCompoundCommand");
  285.     if (version == 0) NXReadTypes(stream, "i", &version), version = 1;
  286.     if (version == 1)
  287.     {  NXReadTypes(stream, typeVector, typeValues);
  288.        NXReadArray(stream, "f", 6, boundingBox);
  289.        myShape = NXReadObject(stream);
  290.     }
  291.  
  292.     return self;
  293. }
  294.  
  295. - write:(NXTypedStream *)stream 
  296. {
  297.     [super write:stream];
  298.     NXWriteTypes(stream, typeVector, typeValues);
  299.     NXWriteArray(stream, "f", 6, boundingBox);
  300.     NXWriteObjectReference(stream, myShape);
  301.     return self;
  302. }
  303.  
  304. - (BOOL)theSameAs:otherRIBCommand
  305. {
  306.   if ([self class] != [otherRIBCommand class])
  307.   {  return NO;
  308.   }
  309.  
  310.   return [ribCommandList theSameAs:[otherRIBCommand ribCommandList]];
  311. }
  312.  
  313. - (BOOL)similarTo:otherRIBCommand 
  314. {
  315.   if ([self class] != [otherRIBCommand class])
  316.   {  return NO;
  317.   }
  318.   return YES;
  319. }
  320.  
  321. - (BOOL)isMoot
  322. {
  323.   return [ribCommandList isMoot];
  324. }
  325.  
  326. - (BOOL)isMootStartingAt:(float)startTime endingAt:(float)endTime  {  return [self isMoot];  }
  327.  
  328. // boy, this is dumb... This is to get around the stupid warnings from the compiler - ask wave for details
  329. - class { return [super class]; }
  330.  
  331. @end
  332.